Thread: cannot convert parameter 3 from 'unsigned short *[]' to 'const unsigned short *[]'

A pointer's pointed-to type can have const added to it, but that's not the case here.

What you have here is
a) unsigned short **: pointer to 'pointer to unsigned short'
b) const unsigned short **: pointer to 'pointer to const unsigned short'

As you can see, the pointer did not just gain a const in the pointee. That would have been unsigned short *const *: pointer to 'const pointer to unsigned short'.

Now, why doesn't this conversion work? Consider (using int instead of unsigned short):

Code:

const int ci = 4; // Valid
const int *pci = &ci; // Valid
int *pi; // Valid
int **ppi = π // Valid
const int **ppci = ppi; // Valid ???
*ppci = pci; // Valid !!! (But pi now points at ci!)
*pi = 5; // Changes ci!

Allowing this conversion would allow subversion of the type system without any warning whatsoever.

I believe CornedBee explained it well. You may want to take a look at his reply.

But shortly, remember to read pointer declarations from right to left. That helps establish exactly what kind of pointer you have.

In your first case you had a pointer to a pointer to const tchar.
In your last case, you have a const pointer to a pointer to const TCHAR.

In the first case your pointer wasn't const.

Qualification conversions are described in 4.4 of the standard. The basic rule is:

Originally Posted by 4.4/1

An rvalue of type "pointer to cv1 T" can be converted to an rvalue of type "pointer to cv2 T" if "cv2 T" is more cv-qualified than "cv1 T."

OK, let's recap. In function arguments, [] is equivalent to *, so the type of main's argv (let's assume _UNICODE isn't defined, so it's TCHAR=char) is char**. Mapping this to the pattern "pointer to cv1 T", we end up with cv1=nothing and T=char*.
The type of Func's argv is const char**. Mapped to the pattern, cv2=nothing and T=const char*.
Since the Ts aren't equal, the primary rule of qualification conversion does not apply.

If, on the other hand, Func's argv was char*const*, we'd get cv2=const and T=char*, meaning that the Ts are equal and cv2 is more cv-qualified than cv1. The rule applies, and conversion can be performed.

Now this is where it gets complicated. Paragraph 4 starts:

Originally Posted by 4.4/4

A conversion can add cv-qualifiers at levels other than the first in multi-level pointers, subject to the following rules:

The rules are described formally and are thus hard to understand. It boils down to two rules:
1) You can't remove anything.
2) If you add const or volatile somewhere, you have to add const to all pointers "further out", too.

Some examples:

Code:

int * const * const volatile * volatile *p1;
int * const * const * volatile *p2 = p1; // Not allowed: removes something.
int * const * const volatile * const volatile *p3 = p1; // Allowed: const added at outermost level.
int *const volatile * const volatile * volatile *p4 = p1; // Not allowed: change, but not all levels further out
                                                          // (to the right of the change) are const.
const int * const * const volatile * volatile *p5 = p1; // Not allowed: as above.
const int * const * const volatile * const volatile *p6 = p1; // Allowed: change at innermost type, but everything to the right is const.

In your case, your last try was const TCHAR*const *, which is valid. You added const to the leftmost type, but also to everything to the right of it.